ValidatedField

abstract class ValidatedField<T>(storedValue: T, defaultValue: T = storedValue) : Entry<T, ValidatedField<T>> , Updatable, Translatable

Validated Field Collection - serialization is indistinguishable from their wrapped values, but deserialized into a validated wrapper

Validated Fields CANNOT be serialized and deserialized by GSON or other "automagic" serializers properly. The Toml Element does not provide enough context, because the validation is hidden within code only, not serialized. These fields are not building new classes from scratch, they are updating and validating a pre-existing default class framework.

Helper methods are provided to more easily sync configs directly via PacketByteBufs, rather than serializing and then deserializing the entire JSON

Author

fzzyhmstrs

Since

0.1.0

Parameters

T

Type of the wrapped value

storedValue

T. The wrapped value that this field validates, serializes, and syncs between server and client.

defaultValue

T. The default value of the wrapped value

Samples

import com.mojang.brigadier.LiteralMessage
import me.fzzyhmstrs.fzzy_config.fcId
import me.fzzyhmstrs.fzzy_config.util.FcText
import me.fzzyhmstrs.fzzy_config.util.FcText.bold
import me.fzzyhmstrs.fzzy_config.util.FcText.command
import me.fzzyhmstrs.fzzy_config.util.FcText.descLit
import me.fzzyhmstrs.fzzy_config.util.FcText.lit
import me.fzzyhmstrs.fzzy_config.util.FcText.text
import me.fzzyhmstrs.fzzy_config.util.FcText.tooltip
import me.fzzyhmstrs.fzzy_config.util.FcText.transLit
import me.fzzyhmstrs.fzzy_config.util.FcText.translate
import me.fzzyhmstrs.fzzy_config.util.FcText.underline
import me.fzzyhmstrs.fzzy_config.util.Translatable
import net.minecraft.registry.RegistryKeys
import net.minecraft.registry.tag.TagKey
import net.minecraft.util.Identifier
import net.minecraft.util.math.ChunkPos
import java.util.*

fun main() { 
   //sampleStart 
   //fields and sections have lang keys based on their "location" in the Config class graph.
//Lange key composition is as follows
//1. the namespace of the config id: (my_mod)
//2. the path of the config id: (my_mod.my_config)
//3. any parent ConfigSection field names as declared in-code: (my_mod.my_config.subSection)
//4. the setting field name as declared in-code: (my_mod.my_config.subSection.fieldName)
val lang = """
    {
        "_comment1": "the lang for an example 'fieldName' setting in a config inside section 'subSection'",
        "my_mod.my_config.subSection.fieldName": "Very Important Setting",
        "my_mod.my_config.subSection.fieldName.desc": "This very important setting is used in this very important way.",
        
        "_comment2": "this is the lang for the corresponding subSection",
        "my_mod.my_config.subSection": "Important Settings",
        "my_mod.my_config.subSection.desc": "Important settings related to important things are in this section."
        
        "_comment2": "the lang for the base config itself",
        "my_mod.my_config": "My Mod's Config",
        "my_mod.my_config.desc": "Lots of really cool config settings live in this config."
    }
    """ 
   //sampleEnd
}

Inheritors

Constructors

Link copied to clipboard
constructor(storedValue: T, defaultValue: T = storedValue)

Types

Link copied to clipboard
object Companion

Functions

Link copied to clipboard
open override fun accept(input: T)

updates the wrapped value. NOTE: this method will push updates to an UpdateManager, if any. For in-game updating consider validateAndSet

Link copied to clipboard
open fun addListener(listener: Consumer<ValidatedField<T>>)

Attaches a listener to this field. This listener will be called any time the field is written to ("set"). accept, validateAndSet, setAndUpdate and so on will all call the listener.

Link copied to clipboard
open fun andThen(p0: Consumer<in T>): Consumer<T>
Link copied to clipboard
Link copied to clipboard
fun codec(): Codec<T>

Provides a Codec representing the value type of this validation, backed by the validators within, as applicable

Link copied to clipboard
open fun copyStoredValue(): T

Copies the stored value and returns it.

Link copied to clipboard
Link copied to clipboard
open fun description(fallback: String? = null): MutableText

The translated Text description from the descriptionKey. Falls back to an empty string so no tooltip is rendered.

Link copied to clipboard
open override fun descriptionKey(): String

translation key of this Translatable's description. the "description" in-game, the descriptions Enchantment Descriptions adds to enchantment tooltips are a good example.

Link copied to clipboard
abstract fun deserialize(toml: TomlElement, fieldName: String): ValidationResult<T>

deserializes the fields stored value from TomlElement. This should not set the fields stored value, or interact with the field at all except to get the stored value for error reporting. deserializeEntry handles that.

Link copied to clipboard
open override fun get(): T

supplies the wrapped value

Link copied to clipboard
fun getDefault(): T

Provides this validations default value

Link copied to clipboard

Whether this Translatable has a valid description

Link copied to clipboard

Whether this Translatable has a valid translation

Link copied to clipboard
abstract fun instanceEntry(): ValidatedField<T>
Link copied to clipboard
abstract fun isValidEntry(input: Any?): Boolean
Link copied to clipboard
fun <N> map(to: Function<T, out N>, from: Function<in N, T>): ValidatedField<N>

Maps this validation to a new convertible type. The default value will be applied from this delegates current storedValue

fun <N> map(defaultValue: N, to: Function<T, out N>, from: Function<in N, T>): ValidatedField<N>
fun <N> map(to: Function<T, out N>, from: Function<in N, T>, defaultValue: T): ValidatedField<N>

Maps this validation to a new convertible type.

Link copied to clipboard
abstract fun serialize(input: T): ValidationResult<TomlElement>

Serializes the provided input to a TomlElement

Link copied to clipboard
fun toList(vararg elements: T): ValidatedList<T>

wraps the provided values into a ValidatedList with this field as validation

fun toList(collection: Collection<T>): ValidatedList<T>

wraps the provided collection into a ValidatedList with this field as validation

Link copied to clipboard
fun toSet(vararg elements: T): ValidatedSet<T>

wraps the provided values into a ValidatedSet with this field as validation

fun toSet(collection: Collection<T>): ValidatedList<T>

wraps the provided collection into a ValidatedList with this field as validation

Link copied to clipboard
open override fun translation(fallback: String?): MutableText

The translated Text name from the translationKey. Falls back to the implementing classes Simple Name (non-translated)

Link copied to clipboard
open override fun translationKey(): String

translation key of this Translatable. the "name" in-game

Link copied to clipboard
fun trySerialize(input: Any?, errorBuilder: MutableList<String>, flags: Byte): TomlElement?
Link copied to clipboard
open override fun trySet(input: Any?)
Link copied to clipboard
open fun update(updateMessage: Text)
Link copied to clipboard
open fun validateAndSet(input: T): ValidationResult<T>

A setter method for the storedValue that first validates the value being set and then stores the post-validation result.

Link copied to clipboard
Link copied to clipboard
open fun widgetAndTooltipEntry(choicePredicate: ChoiceValidator<T> = ChoiceValidator.any()): ClickableWidget
Link copied to clipboard
abstract fun widgetEntry(choicePredicate: ChoiceValidator<T> = ChoiceValidator.any()): ClickableWidget